Btw, adding #define BOOST_SPIRIT_X3_DEBUG will break this sample program again.

I'm not sure about this one. Why do you have to wrap the container into a fusion vector? Why not simply use std::vector and std::vectorstd::vector ?

Why not?

I'm not saying "you have to". This might be the result of simplification of some existing code. Do you want to not to compile simpler version of the code? Then static_assert would help a lot. Or this might be the 1st parser someone new to the library (like myself) trying to write.

If I'd adapting the existring struct, I could write using value_type = whatever;, but with BOOST_FUSION_DEFINE_STRUCT_INLINE there is no way I can do it.

Why variable here https://github.com/boostorg/spirit/blob/develop/example/x3/calc/calc9/ast.hpp#L27 is not a string?

Btw, ast::a3 is unchanged from my previous pull request (it was single element seqence too). Only thing changed is a3 rule from this:

auto a3_v1 = rule<class a3_v1, std::vector<ast::a2>>{} = *(a2 >> ';');
auto a3    = rule<class i3, ast::a3>{}                 = a3_v1;

to this

auto a3    = rule<class i3, ast::a3>{}                 = *(a2 >> ';');

And now it suddenly requires value_type to be defined.

I'll have to think about this some more as it introduces a new behavior. The previous behavior in which you provided a patch for is suspicious to begin with. What we should probably do is to distill the test code to the bare essentials so I (we) can analyze and reason out with the correct behavior. I fear that we are opening a can of worms if we allow single-element-tuple-with-container == container.

MWE:

#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/include/define_struct_inline.hpp>
#include <string>

namespace ast
{
BOOST_FUSION_DEFINE_STRUCT_INLINE
(
    a3,
    (std::vector<int>, v1)
)
}

int main()
{
    namespace x3 = boost::spirit::x3;

    auto test = [](std::string s, auto&& p)
    {
        ast::a3 v;

        auto it = s.begin();
        return (x3::phrase_parse(it, s.end(), p, x3::space, v) && it == s.end());
    };

    test("1 2 3 ", *x3::int_);          // OK
    test("1;2;3 ",  x3::int_ % ';');    // OK
    test("1;2;3;", *(x3::int_ >> ';')); // Fail to compile
}